package com.dcjt.firehotcarpad.utils

import android.content.Context
import com.amap.api.location.DPoint
import com.amap.api.maps.CoordinateConverter
import com.amap.api.maps.model.LatLng
import com.amap.api.services.core.LatLonPoint


object Converter {
    private val a = 6378245.0
    private val pi = 3.14159265358979324
    private val ee = 0.00669342162296594323

    // WGS-84 to GCJ-02  火星转高德
    fun toGCJ02Point(
        latitude: Double,
        longitude: Double
    ): LatLonPoint? {
        val dev = calDev(latitude, longitude)
        val retLat = latitude + dev.latitude
        val retLon = longitude + dev.longitude
        return LatLonPoint(retLat, retLon)
    }
    // WGS-84 to GCJ-02  火星转高德
    fun toGCJ02Point_latlon(
        latitude: Double,
        longitude: Double
    ): LatLng {
        val dev = calDev(latitude, longitude)
        val retLat = latitude + dev.latitude
        val retLon = longitude + dev.longitude
        return LatLng(retLat, retLon)
    }
    // WGS-84 to GCJ-02  火星转高德
    fun toGCJ02Point_DPoint(
        latitude: Double,
        longitude: Double
    ): DPoint {
        val dev = calDev(latitude, longitude)
        val retLat = latitude + dev.latitude
        val retLon = longitude + dev.longitude
        return DPoint(retLat, retLon)
    }

    // GCJ-02 to WGS-84  高德转火星
    fun toWGS84Point(
        latitude: Double,
        longitude: Double): LatLonPoint {
        var dev = calDev(latitude, longitude)
        var retLat = latitude - dev.latitude
        var retLon = longitude - dev.longitude
        dev = calDev(retLat, retLon)
        retLat = latitude - dev.latitude
        retLon = longitude - dev.longitude
        return LatLonPoint(retLat, retLon)
//        val converter = CoordinateConverter(context)
//        converter.from(CoordinateConverter.CoordType.GPS)
//        converter.coord(LatLng(latitude,longitude))
//        val desLatLng: LatLng = converter.convert()
//        return LatLonPoint(desLatLng.latitude,desLatLng.longitude)
    }

    private fun calDev(
        wgLat: Double,
        wgLon: Double
    ): LatLonPoint {
        if (isOutOfChina(wgLat, wgLon)) {
            return LatLonPoint(0.0, 0.0)
        }
        var dLat = calLat(wgLon - 105.0, wgLat - 35.0)
        var dLon = calLon(wgLon - 105.0, wgLat - 35.0)
        val radLat = wgLat / 180.0 * pi
        var magic = Math.sin(radLat)
        magic = 1 - ee * magic * magic
        val sqrtMagic = Math.sqrt(magic)
        dLat = dLat * 180.0 / (a * (1 - ee) / (magic * sqrtMagic) * pi)
        dLon = dLon * 180.0 / (a / sqrtMagic * Math.cos(radLat) * pi)
        return LatLonPoint(dLat, dLon)
    }

    private fun isOutOfChina(lat: Double, lon: Double): Boolean {
        return if (lon < 72.004 || lon > 137.8347) true else lat < 0.8293 || lat > 55.8271
    }

    private fun calLat(x: Double, y: Double): Double {
        var ret =
            -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + (0.2
                    * Math.sqrt(Math.abs(x)))
        ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0
        ret += (20.0 * Math.sin(y * pi) + 40.0 * Math.sin(y / 3.0 * pi)) * 2.0 / 3.0
        ret += (160.0 * Math.sin(y / 12.0 * pi) + 320 * Math.sin(y * pi / 30.0)) * 2.0 / 3.0
        return ret
    }

    private fun calLon(x: Double, y: Double): Double {
        var ret =
            300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(
                Math.abs(x)
            )
        ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0
        ret += (20.0 * Math.sin(x * pi) + 40.0 * Math.sin(x / 3.0 * pi)) * 2.0 / 3.0
        ret += (150.0 * Math.sin(x / 12.0 * pi) + 300.0 * Math.sin(x / 30.0 * pi)) * 2.0 / 3.0
        return ret
    }

}